package layui.dao.impl;

import layui.util.DbUtil;
import layui.dao.UserDao;
import layui.entity.User;
import layui.util.DbUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

/**
 * @Author zqx
 * @Date 2023-11-15
 */
public class UserDaoImpl implements UserDao {
    @Override
    public User selectUser(String username) {
        User user = null ;
        //第一：定义操作数据库的SQL语句
        String sql = "select id,username,password,level,image,phone,email,register_time,status from users where username=?" ;

        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        ResultSet rst = null ;
        try {
            pstmt= conn.prepareStatement(sql);

            //第四：设置数据
            //语法：语句对象.setXxx(问号占位符索引,数据) ;
            pstmt.setString(1,username);

            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            rst = pstmt.executeQuery() ;
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;

            if(rst.next()) {
                // 1.读取数据
                int id = rst.getInt(1) ;
                String password = rst.getString(3) ;
                String level = rst.getString(4) ;
                String image = rst.getString(5) ;
                String phone = rst.getString(6) ;
                String email = rst.getString(7) ;
                Date regTime = rst.getTimestamp(8) ;
                int status = rst.getInt(9) ;

                // 2.创建实体对象
                user = new User() ;

                //3.封装数据
                user.setId(id);
                user.setUsername(username);
                user.setPassword(password);
                user.setLevel(level);
                user.setImage(image);
                user.setPhone(phone);
                user.setEmail(email);
                user.setRegisterTime(regTime);
                user.setStatus(status);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,rst);
        }
        return user;
    }

    @Override
    public List<User> selectUser(User user) {
        return null;
    }

    @Override
    public Long selectUserByPageCount(User user) {
        return null;
    }

    @Override
    public List<User> selectUserByPage(User user, Integer page, Integer limit) {
        return null;
    }

    @Override
    public int delete(int id) {
        int r = 0 ;

        // 第一：定义操作数据库的SQL语句，动态添加条件
        String sql = "delete from users where id=?" ;


        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        try {
            pstmt= conn.prepareStatement(sql.toString());

            //第四：设置数据
            pstmt.setInt(1,id);


            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            r = pstmt.executeUpdate();
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,null);
        }
        return r;
    }

    @Override
    public int update(User user) {
        int r = 0 ;
        //第一：定义操作数据库的SQL语句
        String sql = "update users set level=?,phone=?,email=?,status=? where id=?" ;

        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        try {
            pstmt= conn.prepareStatement(sql);

            //第四：设置数据
            //语法：语句对象.setXxx(问号占位符索引,数据) ;

            pstmt.setString(1,user.getLevel());
            pstmt.setString(2,user.getPhone());
            pstmt.setString(3,user.getEmail());
            pstmt.setInt(4,user.getStatus());
            pstmt.setInt(5,user.getId());

            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            r = pstmt.executeUpdate() ;
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,null);
        }
        // 返回受影响行数
        return r;
    }

    @Override
    public int insert(User user) {
        int r = 0 ;
        //第一：定义操作数据库的SQL语句
        String sql = "insert into users(username,password,level,phone,status) values (?,?,?,?,?)" ;

        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        try {
            pstmt= conn.prepareStatement(sql);

            //第四：设置数据
            //语法：语句对象.setXxx(问号占位符索引,数据) ;

            pstmt.setString(1,user.getUsername());
            pstmt.setString(2,user.getPassword());
            pstmt.setString(3,user.getLevel());
            pstmt.setString(4,user.getPhone());
            pstmt.setInt(5,1);


            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            r = pstmt.executeUpdate() ;
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,null);
        }
        // 返回受影响行数
        return r;
    }

    @Override
    public int updateHead(String username, String head) {
        int r = 0 ;
        //第一：定义操作数据库的SQL语句
        String sql = "update users set image=? where username=?" ;

        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        try {
            pstmt= conn.prepareStatement(sql);

            //第四：设置数据
            //语法：语句对象.setXxx(问号占位符索引,数据) ;

            pstmt.setString(1,head);
            pstmt.setString(2,username);


            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            r = pstmt.executeUpdate() ;
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,null);
        }
        // 返回受影响行数
        return r;
    }

    @Override
    public int updatePwd(String username, String pass) {
        int r = 0 ;
        //第一：定义操作数据库的SQL语句
        String sql = "update users set password=? where username=?" ;

        //第二：获取连接对象
        Connection conn = DbUtil.getConnection();

        //第三：使用连接对象，获取语句对象(PreparedStatement)，并预编译SQL语句
        PreparedStatement pstmt = null ;
        try {
            pstmt= conn.prepareStatement(sql);

            //第四：设置数据
            //语法：语句对象.setXxx(问号占位符索引,数据) ;
            pstmt.setString(1,pass);
            pstmt.setString(2,username);

            //第五：执行SQL语句，并接收返回结果
            //语句对象.executeUpdate() -> 增,删,改	   ->  返回的是受影响的记录数
            //语句对象.executeQuery()  -> 查			-> 	返回的是结果集(ResultSet)
            r = pstmt.executeUpdate() ;
            //第六：对结果进行处理
            //遍历结构集各行各列的数据，封装到相关的实体对象或集合
            //判断有没有数据:结果集对象.next()
            //获取结果集的数据:
            //结果集对象.getXxx(查询数据的索引) ;
            //结果集对象.getXxx(查询数据的字段名称) ;

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 第七：关闭对象
            DbUtil.close(conn,pstmt,null);
        }
        // 返回受影响行数
        return r;
    }
}
